home *** CD-ROM | disk | FTP | other *** search
/ Resource Library: Multimedia / Resource Library: Multimedia.iso / sgml / unix / sgmlc / modpars2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-03  |  50.9 KB  |  1,162 lines
  1. /******************************************************************************/
  2. /* PARSEVAL: Added support for ENTITIES. */
  3. /* CHARREFN: Now returns MLA_ if reference occurred in a literal. */
  4. /* PARSE:    Does not return if charrefn found invalid reference. */
  5. /******************************************************************************/
  6. #include "sgmlincl.h"         /* #INCLUDE statements for SGML parser. */
  7. /******************************************************************************/
  8. /* PARSE: Parse a source input stream with specified lexical and state tables.
  9.           Return to caller with action code.
  10. */
  11. /*lint +fvr                      Returned value may be ignored. */
  12. int parse(pcb)
  13. /*lint -fvr                      Restore normal LINT processing. */
  14. struct parse *pcb;            /* Current parse control block. */
  15. {
  16.      int rc;                  /* Return code from ENTREF. */
  17.      int stagrc;              /* Return code from stagetd(). */
  18.  
  19. /*lint -e716*/
  20.      while (1) {
  21. /*lint +e716*/
  22.           NEWCC;
  23.           pcb->input = pcb->plex[*FPOS];
  24.           pcb->state = pcb->newstate;
  25.           pcb->newstate = (*(pcb->ptab + pcb->state)) [pcb->input];
  26.           pcb->action = (*(pcb->ptab + pcb->state + 1)) [pcb->input];
  27. #ifndef FINAL
  28.           if (trace) tracepcb(pcb);
  29. #endif
  30.           switch (pcb->action) {
  31.           case RC2_:          /* Back up two characters. */
  32.                REPEATCC;
  33.           case RCC_:          /* Repeat current character. */
  34.                REPEATCC;
  35.           case NOP_:          /* No action necessary.*/
  36.                continue;
  37.  
  38.           case RS_:           /* Record start: ccnt=0; ++rcnt.*/
  39.                ++RCNT; CTRSET(RSCC);
  40.                continue;
  41.  
  42.           case GET_:          /* EOB or dull EOS or EE found: keep going.*/
  43.                if (entget()==-1) {pcb->action = EOD_; break;}/* Signal if EOD.*/
  44.                continue;
  45.  
  46.           case EOF_:          /* Illegal entity end; return EE_. */
  47.                synerr(_EOF, pcb);
  48.                pcb->action = EE_;
  49.           case EE_:           /* Important EOS or EE found: return to caller.*/
  50.                if (entget()==-1) pcb->action = EOD_;   /* Signal if EOD. */
  51.                break;
  52.  
  53.           case PER_:          /* Parameter entity reference. */
  54.                REPEATCC;           /* Use PERO as 1st char of entity name. */
  55.                parsenm(entbuf, ENTCASE);
  56.                parse(&pcbref);     /* Handle REFC or other terminator. */
  57.                rc = entref(entbuf);
  58.                if (rc==ENTSGI || rc==ENTEGI) {entfix(entbuf); entref(entbuf);}
  59.                if (rc==ENTPI) {pcb->action = PIE_; break;}
  60.                continue;
  61.  
  62.           case ER_:           /* General entity reference; continue. */
  63.                parsenm(entbuf, ENTCASE);
  64.                parse(&pcbref);     /* Handle REFC or other terminator. */
  65.                if ((rc = entref(entbuf))==ENTSGI) {
  66.                     if ((stagrc = stagetd(pcb))==0) continue;
  67.                     pcb->action = stagrc; break;
  68.                }
  69.                if (rc==ENTEGI && etagetd(pcb)) {pcb->action = ETG_; break;}
  70.                if (rc==ENTDATA) {pcb->action = DEF_; break;}
  71.                if (rc==ENTPI) {pcb->action = PIE_; break;}
  72.                continue;
  73.  
  74.  
  75.           case PEX_:          /* Parameter entity reference; return. */
  76.                REPEATCC;           /* Use PERO as 1st char of entity name. */
  77.           case ERX_:          /* General entity reference; return. */
  78.                parsenm(entbuf, ENTCASE);
  79.                parse(&pcbref);     /* Handle REFC or other terminator. */
  80.                rc = entref(entbuf);
  81.                if (rc==ENTSGI || rc==ENTEGI) {entfix(entbuf);rc=entref(entbuf);}
  82.                if (rc==ENTDATA) pcb->action = DEF_;
  83.                else if (rc==ENTPI) pcb->action = PIE_;
  84.                else if (rc) pcb->action = EE_;
  85.                break;
  86.  
  87.           case CRN_:          /* Character reference: numeric. */
  88.                parsetkn(entbuf, NU, 8);
  89.                parse(&pcbref);     /* Handle reference terminator. */
  90.                pcb->action = charrefn(entbuf, pcb);
  91.                if (pcb->action==CRN_) continue;   /* Invalid reference */
  92.                break;
  93.  
  94.           case CRA_:           /* Character reference: alphabetic. */
  95.                parsenm(entbuf, NAMECASE);
  96.                parse(&pcbref);     /* Handle reference terminator. */
  97.                charrefa(entbuf);
  98.                continue;
  99.  
  100.           case SYS_:          /* Invalid NONCHAR: send msg and ignore. */
  101.                synerr(_SYS, pcb);
  102.                continue;
  103.  
  104.           case NON_:          /* Valid NONCHAR: prefix and shift encoding. */
  105.                synerr(60, pcb);
  106.                nonchbuf[1] = shiftnon(*FPOS);
  107.                break;
  108.  
  109.           case PCI_:          /* Previous character was invalid (INV_). */
  110.                REPEATCC;
  111.           case INV_:          /* Markup ended by invalid char; repeat char. */
  112.                synerr(9, pcb);
  113.                REPEATCC;
  114.                break;
  115.  
  116.           case LNR_:          /* Previous char exceeded len; back up to it. */
  117.                REPEATCC;
  118.           case LEN_:          /* Token too long; ignore excess character. */
  119.                synerr(3, pcb);
  120.                continue;
  121.  
  122.           case RCR_:          /* Repeat current char and return to caller. */
  123.                REPEATCC;
  124.           default:            /* Actions for specific parse. */
  125.                break;
  126.           }
  127.           return (int)pcb->action;
  128.      }
  129.      /*lint unreachable*/
  130. }
  131. /******************************************************************************/
  132. /* CHARREFA: Resolve an alphabetical reference to a function character
  133.              and put the character in the read buffer.
  134.              If reference is bad, issue an error message.
  135. */
  136. VOID charrefa(r)
  137. UNCH *r;                      /* Undelimited char ref (with length and EOS). */
  138. {
  139.      if ((*FPOS = (UNCH)mapsrch(funtab, r+1))!=0) REPEATCC;
  140.      else synerr(62, &pcbref);
  141.      return;
  142. }
  143. /******************************************************************************/
  144. /* CHARREFN: Resolve a numeric
  145.              character reference and put the char in the read buffer.
  146.              If reference is to a non-character or function character,
  147.              shift it to a valid code and place it in a special buffer
  148.              which has sw.delnonch in the preceding byte.
  149.              If reference is bad, issue an error message.
  150. */
  151. int charrefn(r, pcb)
  152. UNCH *r;                      /* Undelimited character reference. */
  153. struct parse *pcb;            /* Current parse control block. */
  154. {
  155.      int thechar;             /* The referenced character. */
  156.  
  157.      thechar = atoi(r+1);
  158.      if (thechar<0 || thechar>255) {                   /* No char at all. */
  159.           synerr(61, &pcbref);
  160.           return((int)pcb->action);
  161.      }
  162.      if (thechar<33 || thechar==127 || thechar==255) { /* Non-SGML char. */
  163.           nonchbuf[1] = shiftnon((UNCH)thechar);
  164.           return NON_;
  165.      }
  166.      *FPOS = (UNCH)thechar;                            /* Good SGML char. */
  167.      /* If in content, return DCE_ for element content, DAS_ for mixed.  */
  168.      /* If not content, it must be a literal parse, so return MLA_. */
  169.      return(pcb==conpcb ? (pcb==&pcbcone ? DCE_ : DAS_) : MLA_);
  170. }
  171. /****************************************************************************/
  172. /* SHIFTNON: Convert a non-SGML character to an SGML character by
  173.              adding an offset to it (sw.addnonch) modulo 256.
  174. */
  175. UNCH shiftnon(nonchar)
  176. UNCH nonchar;                 /* Non-SGML character. */
  177. {
  178.      return (UNCH)((nonchar+sw.addnonch) % 256);
  179. }
  180. /******************************************************************************/
  181. /* PARSEATT: Parse attribute specification list.
  182.              Make a current copy of the attribute definition list
  183.              and update it with the user's specifications.
  184.              Indicate each attribute that was specified in the
  185.              list (as opposed to defaulted) by setting the ASPEC flag.
  186.              If no attributes were specified, return NULL.  Otherwise,
  187.              if in the prolog, make a permanent copy of the list and
  188.              return its pointer.  If not in the prolog, return al.
  189. */
  190. struct ad *parseatt(adl, pt, tbuflim)
  191. struct ad *adl;               /* Attribute definition list. */
  192. UNCH *pt;                     /* Tokenization area: tbuf[TAGLEN+ATTSPLEN]. */
  193. UNCH *tbuflim;                /* 1st addr after pt+ATTSPLEN: avoid overruns.*/
  194. {
  195.      UNCH *nm;                /* Pointer to saved name in tbuf (with length). */
  196.      int adn = -1;            /* Position of attribute in list (-1=empty). */
  197.      struct ad *alperm = 0;   /* Permanent copy of attribute list. */
  198.  
  199.      mdessv = es;             /* Save es for checking entity nesting. */
  200.      idrefl = 0;              /* Clear IDREF existence switches. */
  201.      notadn = 0;              /* No NOTATION attribute yet. */
  202.      conrefsw = 0;            /* Assume no content reference att. */
  203.      /* Copy attribute definition list as a template. */
  204.      memcpy( (UNIV)al , (UNIV)adl, (1+adl[0].adtype)*ADSZ );
  205.      while (pt<=tbuflim) {
  206.           parse(&pcbstag);
  207.           switch (pcbstag.action) {
  208.           case NVS:                     /* Att name or value token found. */
  209.                parsenm(pt, NAMECASE);   /* Case translation wanted on name. */
  210.                pt += *(nm = pt);        /* Save name while pointing past it. */
  211.                continue;
  212.  
  213.           case AVD:           /* Delimited value found. */
  214.           case AVDA:          /* Delimited value found (alternate delimiter). */
  215.                parselit(pt, &pcblitr, LITLEN,
  216.                         (pcbstag.action==AVD) ? lex.d.lit : lex.d.lita);
  217.           case AVU:           /* Attribute value found: undelimited. */
  218.                if (pcbstag.action==AVU) parsetkn(pt, NMC, LITLEN);
  219.                /* Find position (adn) of saved attribute name in list. */
  220.                if ((adn = anmget((int)ADN, nm))==0) {
  221.                     /* Error: unrecognized attribute name. */
  222.                     sgmlerr(13, &pcbstag, nm+1, pt+1);
  223.                     continue;
  224.                }
  225.                /* Tokenize and validate value; let it default if an error. */
  226.                /* Put value in list and bump ptr by the normalized length
  227.                   (which is always >= the actual length). */
  228.                if (!attval(1, pt, adn, adl)) pt += ADLEN(adn);
  229.                continue;
  230.  
  231.           case NASV:          /* Saved NVS was really an NTV. */
  232.                REPEATCC;           /* Put back next token starter. */
  233.                pt = nm;            /* Back up to NVS. */
  234.           case NTV:           /* Name token value found. */
  235.                if (pcbstag.action==NTV) parsenm(pt, NAMECASE);
  236.                if ((adn = antvget((int)ADN, pt))==0) {
  237.                     /* Error: unrecognized name token value. */
  238.                     sgmlerr(74, &pcbstag, pt+1, NULL);
  239.                     continue;
  240.                }
  241.                /* Validate value; let it default if an error. */
  242.                /* Put value in list and bump ptr by the normalized length
  243.                   (which is always >= the actual length). */
  244.                if (!attval(0, antvptr, adn, adl)) pt += ADLEN(adn);
  245.                continue;
  246.  
  247.           default:            /* All attributes have been parsed. */
  248.                REPEATCC;      /* Put next char back for tag close parse. */
  249.                break;
  250.           }
  251.           break;
  252.      }
  253.      if (pt>tbuflim) synerr(75, &pcbstag);
  254.      if (es!=mdessv) synerr(37, &pcbstag);
  255.      if (adn<0) return((struct ad *)0); /* List was empty. */
  256.      if (!prologsw) alperm = al;        /* In start-tag, list is temporary. */
  257.      else {
  258.           alperm = (struct ad *)rmalloc((1+ADN)*ADSZ);
  259.           memcpy((UNIV)alperm, (UNIV)al, (1+ADN)*ADSZ );
  260.      }
  261. #ifndef FINAL
  262.      if (atrace) traceadl(alperm);
  263. #endif
  264.      return(alperm);
  265. }
  266. /******************************************************************************/
  267. /* ATTVAL: Validate a specified attribute value.  Issue a message if it is
  268.            the wrong type (or otherwise is not up to spec), and use the default.
  269.            Call PARSEVAL to tokenize the value, unless it is a CDATA string.
  270.            If the attribute is a group, the value is a string.
  271.            For other types, the token count is set by PARSEVAL if the value
  272.            is syntactically correct.  If incorrect (or if CDATA) the token
  273.            count is zero (i.e., the value is a string).
  274.            The length of a token does not include the length byte, and
  275.            there is no EOS.  A string length (as always) includes both
  276.            the length byte and the EOS.
  277.            If it is a CONREF attribute, set a switch for STAG().
  278.            If it is a CURRENT attribute, store the value as the new default.
  279. */
  280. #define DEFVAL adl[adn].addef /* Default value of current attribute. */
  281. #define DEFNUM adl[adn].adnum /* Default group size of current attribute. */
  282. #define DEFLEN adl[adn].adlen /* Length of default value of current attribute.*/
  283. int attval(mtvsw, adval, adn, adl)
  284. int mtvsw;                    /* Must tokenize value: 1=yes; 0=no. */
  285. UNCH *adval;                  /* Untokenized attribute value. */
  286. int adn;                      /* Attribute's position in list. */
  287. struct ad *adl;               /* Element's master att def list. */
  288. {
  289.      int errcode;             /* Value/declaration conflict error code. */
  290.  
  291.      if (GET(ADFLAGS(adn), ASPEC))      /* Can't respecify same attribute. */
  292.           {sgmlerr(73, &pcbstag, ADNAME(adn), adval+1); return(1);}
  293.      SET(ADFLAGS(adn), ASPEC);          /* Indicate att was specified. */
  294.      if (GET(ADFLAGS(adn), ACONREF))    /* If attribute is content reference: */
  295.           conrefsw = TAGREF;            /* Set switch for STAG(). */
  296.      if (mtvsw && ADTYPE(adn)!=ACHARS) {
  297.           /* If no syntax errors, check for proper group membership. */
  298.           if ( ((errcode = parseval(adval, (UNS)ADTYPE(adn), lbuf))==0)
  299.             && GET(ADFLAGS(adn), AGROUP)
  300.             && !amemget(&al[adn], (int)ADNUM(adn), pvalptr) ) errcode = 18;
  301.           /* If syntax or group membership error, send message and exit. */
  302.           if (errcode) {
  303.                sgmlerr((UNS)errcode, &pcbstag, ADNAME(adn), adval+1);
  304.                SET(ADFLAGS(adn), AERROR);
  305.                return(1);
  306.           }
  307.           /* Replace specified value in adval with tokenized in pvalptr. */
  308.           memcpy( adval , pvalptr, *pvalptr );
  309.           if (BITOFF(ADFLAGS(adn), AGROUP)) ADNUM(adn) = (char)tokencnt;
  310.      }
  311.      /* If attribute is FIXED, specified value must equal default. */
  312.      if (BITON(ADFLAGS(adn), AFIXED) && strcmp(adval, DEFVAL)) {
  313.           sgmlerr(67, &pcbstag, ADNAME(adn), adval+1);
  314.           SET(ADFLAGS(adn), AERROR);
  315.           return(1);
  316.      }
  317.      ADLEN(adn) = (char)vallen(ADTYPE(adn)>=ATKNLIST,
  318.           (int)ADNUM(adn), (ADVAL(adn) = adval));
  319.      /* If attribute is CURRENT, value is new default.*/
  320.      if (GET(ADFLAGS(adn), ACURRENT)) {
  321.           if (ADLEN(adn)>DEFLEN) {
  322.                ds.attdef += (ADLEN(adn) - DEFLEN);
  323.                DEFLEN = ADLEN(adn);
  324.           }
  325.           DEFVAL = replace(DEFVAL, ADVAL(adn));
  326.           DEFNUM = ADNUM(adn);
  327.      }
  328.      return(0);                   /* Indicate value was valid. */
  329. }
  330. /******************************************************************************/
  331. /* ADLVAL: Validate the completed attribute definition list (defaults plus
  332.            specified values).  Issue a message if an
  333.            attribute is required or current and its value is NULL.
  334. */
  335. VOID adlval(adsz, newetd)
  336. int adsz;                     /* Size of list. */
  337. struct etd *newetd;           /* Element type definition for this element. */
  338. {
  339.      int adn = 1;             /* Position in list. */
  340.      UNCH *npt, *pt;          /* Ptr save areas. */
  341.      UNCH nptsv;              /* Save area for ptr value (length?). */
  342.      struct dcncb *dpt;       /* Save area for dcncb ptr. */
  343.  
  344.      aentctr = 0;             /* Number of AENTITY tokens in this att list. */
  345.      idrctr = 0;              /* Number of IDREF tokens in this att list. */
  346.      do {
  347.           if (ADVAL(adn)==NULL) {                      /* NULL value */
  348.                if (GET(ADFLAGS(adn), AREQ+ACURRENT)) { /*Error if REQ, CURRENT*/
  349.                     sgmlerr(19, &pcbstag, ADNAME(adn), NULL);
  350.                     SET(ADFLAGS(adn), AINVALID);
  351.                }
  352.           }
  353.           else switch (ADTYPE(adn)) {
  354.           case AENTITY:       /* Return data ecb pointer if valid entity. */
  355.                aenttst(adn, ADVAL(adn));
  356.                break;
  357.           case AENTITYS:      /* Return data ecb pointers if valid entities. */
  358.                pt = ADVAL(adn)+1;
  359.                tokencnt = (int)ADNUM(adn);
  360.                while (tokencnt--) {
  361.                     nptsv = *(npt = pt + *pt+1);
  362.                     *pt += 2; *npt = EOS;
  363.                     aenttst(adn, pt);
  364.                     *pt -= 2; *(pt = npt) = nptsv;
  365.                }
  366.                break;
  367.           case AID:
  368.                /* If 1st pass define ID; msg if it already exists. */
  369.                if (!pass) {
  370.                     if (iddef(ADVAL(adn), newetd->etdgi)) {
  371.                          sgmlerr(71, &pcbstag, ADNAME(adn), ADVAL(adn)+1);
  372.                          SET(ADFLAGS(adn), AINVALID);
  373.                          continue;
  374.                     }
  375.                     ++ds.idcnt;
  376.                }
  377.                break;
  378.           case AIDREF:
  379.                idreftst(adn, ADVAL(adn), newetd);
  380.                break;
  381.           case AIDREFS:
  382.                pt = ADVAL(adn)+1;
  383.                tokencnt = (int)ADNUM(adn);
  384.                while (tokencnt--) {
  385.                     nptsv = *(npt = pt + *pt+1);
  386.                     *pt += 2; *npt = EOS;
  387.                     idreftst(adn, pt, newetd);
  388.                     *pt -= 2; *(pt = npt) = nptsv;
  389.                }
  390.                break;
  391.           case ANOTEGRP:      /* Return notation identifier. */
  392.                if (GET(ADFLAGS(adn), ASPEC)) notadn = adn;/*NOTATION specified*/
  393.                if ((dpt = dcnfind(ADVAL(adn)))==0) {
  394.                     sgmlerr(77, &pcbstag, ADNAME(adn), ADVAL(adn)+1);
  395.                     SET(ADFLAGS(adn), AINVALID);
  396.                }
  397.                else ADDATA(adn).x = dpt->dcnid;
  398.                break;
  399.           }
  400.      } while ((adn+=BITON(ADFLAGS(adn),AGROUP) ? (int)ADNUM(adn)+1 : 1)<=adsz);
  401.  
  402.      /* Error if NOTATION specified with CONREF attribute or EMPTY element. */
  403.      if (notadn && (conrefsw || GET(newetd->etdmod->ttype, MNONE))) {
  404.           sgmlerr((UNS)(conrefsw ? 84 : 76), &pcbstag,
  405.                ADNAME(notadn), ADVAL(notadn)+1);
  406.           SET(ADFLAGS(notadn), AINVALID);
  407.      }
  408. }
  409. /******************************************************************************/
  410. /* AENTTST: Validate an individual ENTITY token in AENTITY or AENTITYS value.
  411. */
  412. VOID aenttst(adn, pt)
  413. int adn;                      /* Position in list. */
  414. UNCH *pt;                     /* Ptr to current ENTITY token in value. */
  415. {
  416.      struct entity *ept;      /* Save area for ecb ptr. */
  417.  
  418.      if (++aentctr>GRPCNT) {
  419.           sgmlerr(136, &pcbstag, ADNAME(adn), pt+1);
  420.           SET(ADFLAGS(adn), AINVALID);
  421.           return;
  422.      }
  423.      if ( (ept = entfind(pt))==0
  424.        && (ecbdeflt==0 || (ept = usedef(pt))==0) ) {
  425.           sgmlerr(72, &pcbstag, ADNAME(adn), pt+1);
  426.           SET(ADFLAGS(adn), AINVALID);
  427.           return;
  428.      }
  429.      if (ept->estore==ESX || ept->estore==ESC || ept->estore==ESN) {
  430.           aentl[aentctr] = ept;
  431.           /* Error if DCN has no notation identifier. */
  432.           if (ept->estore==ESN && NEDCNID(ept->etx.n)==0) {
  433.                sgmlerr(78, &pcbstag, NEDCN(ept->etx.n)+1,
  434.                            pt+1);
  435.                SET(ADFLAGS(adn), AINVALID);
  436.           }
  437.      }
  438.      else {
  439.           sgmlerr(86, &pcbstag, ADNAME(adn), pt+1);
  440.           SET(ADFLAGS(adn), AINVALID);
  441.      }
  442. }
  443. /******************************************************************************/
  444. /* IDREFTST: Validate an individual IDREF token in an IDREF or IDREFS value.
  445. */
  446. VOID idreftst(adn, pt, newetd)
  447. int adn;                      /* Position in list. */
  448. UNCH *pt;                     /* Ptr to current IDREF token in value. */
  449. struct etd *newetd;           /* Element type definition for this element. */
  450. {
  451.      if (++idrctr>GRPCNT) {
  452.           sgmlerr(70, &pcbstag, ADNAME(adn), pt+1);
  453.           SET(ADFLAGS(adn), AINVALID);
  454.           return;
  455.      }
  456.      /* Pass 1: note IDREF; indicate if ID exists. */
  457.      if (!pass) {
  458.           if (idref(pt, newetd->etdgi)) BITNON(idrefl, idrctr);
  459.           ++ds.idrcnt;
  460.      }
  461.      /* Pass 2: indicate if ID exists; message if not. */
  462.      else {
  463.           if (idget(pt)) BITNON(idrefl, idrctr);
  464.           else {
  465.                sgmlerr(69, &pcbstag, ADNAME(adn), pt+1);
  466.                SET(ADFLAGS(adn), AINVALID);
  467.           }
  468.      }
  469. }
  470. /******************************************************************************/
  471. /* ANMGET: Locate an attribute name in an attribute definition list.
  472. */
  473. int anmget(adsz, nm)
  474. int adsz;                     /* Size of list. */
  475. UNCH *nm;                     /* Value to be found (with length byte). */
  476. {
  477.      int adn = 0;             /* Position in list. */
  478.  
  479.      while (++adn <= adsz && strcmp(nm+1, ADNAME(adn))) {
  480.           if (BITON(ADFLAGS(adn), AGROUP)) adn += (int)ADNUM(adn);
  481.      }
  482.      return (adn > adsz) ? 0 : adn;
  483. }
  484. /******************************************************************************/
  485. /* ANTVGET: Find the position of a name token value in an attribute list.
  486.             Return the position of the attribute definition, or zero
  487.             if none was found.  Set antvptr to the value.
  488. */
  489. int antvget(adsz, nm)
  490. int adsz;                     /* Size of list. */
  491. UNCH *nm;                     /* Value to be found (with length byte). */
  492. {
  493.      int adn = 0;             /* Position in list. */
  494.      int advn = 0;            /* Position of value in sub-list. */
  495.  
  496.      while (++adn<=adsz) {
  497.           /* Test only name group members. */
  498.           if (BITON(ADFLAGS(adn), AGROUP)) {
  499.                if ((advn = amemget(&al[adn], (int)ADNUM(adn), nm))!=0) {
  500.                     antvptr = (UNCH *)al[adn+advn].adname;
  501.                     return adn;
  502.                }
  503.                adn += (int)ADNUM(adn);
  504.           }
  505.      }
  506.      return 0;
  507. }
  508. /******************************************************************************/
  509. /* AMEMGET: Get the position of a member in an attribute name token group.
  510.             Returns the position, or zero if not found.
  511.             The length byte is ignored in the comparison so that final
  512.             form tokens from ATTVAL can be compared to group members.
  513. */
  514. int amemget(anmtgrp, adsz, nm)
  515. struct ad anmtgrp[];          /* Name token group. */
  516. int adsz;                     /* Size of group. */
  517. UNCH *nm;                     /* Name to be found (with length byte). */
  518. {
  519.      int adn = 0;             /* Position in group. */
  520.  
  521.      while ( ++adn<=adsz && strncmp(nm+1, anmtgrp[adn].adname+1, (UNS)*nm-1)) ;
  522.      return (adn>adsz) ? 0 : adn;
  523. }
  524. /******************************************************************************/
  525. /* VALLEN: Returns the length of an attribute value for capacity
  526.            calculations.  Normally, the length is NORMSEP plus the number
  527.            of characters.  For tokenized lists, it is NORMSEP,
  528.            plus the number of characters in the tokens, plus
  529.            NORMSEP for each token.
  530.            NOTE: The active code works when NORMSEP is 2.  The commented
  531.                  code always works.
  532. */
  533. int vallen(tlsw, num, def)
  534. int tlsw;                     /* 1=token list; 0=not. */
  535. int num;                      /* ADNUM(adn) */
  536. char *def;                    /* ADVAL(adn) */
  537. {
  538.      return((int)*def + (tlsw ? num : 0));
  539. /*   return(*def-2 + NORMSEP + (tlsw ? num*(NORMSEP-1) : 0)); */
  540. }
  541. /******************************************************************************/
  542. /* PARSEGRP: Parse GI names, get their etds, and form an array of pointers
  543.              to them.  The array is terminated by a NULL pointer.
  544.              The number of pointers (including the NULL) is returned.
  545.              The grp buffer must have room for GRPCNT+1 etds.
  546. */
  547. /*lint +fvr                      Returned value may be ignored. */
  548. UNS parsegrp(grp, pcb)
  549. /*lint -fvr                      Restore normal LINT processing. */
  550. struct etd *grp[];            /* Buffer for building the group. */
  551. struct parse *pcb;            /* Current parse control block. */
  552. {
  553.      UNCH gi[NAMELEN+2];      /* Buffer for parsing a GI. */
  554.      int grpcnt = 0;          /* Number of etds in the group. */
  555.      int essv = es;           /* Entity stack level when grp started. */
  556.  
  557.      while (parse(pcb)!=GRPE && grpcnt<GRPCNT) {
  558.           switch (pcb->action) {
  559.           case NAS_:          /* GI name: get its etd for the group. */
  560.                grp[grpcnt++] = etddef(parsenm(gi, NAMECASE));
  561.                continue;
  562.  
  563.           case EE_:           /* Entity ended (correctly or incorrectly). */
  564.                if (es<essv) {synerr(37, pcb); essv = es;}
  565.                continue;
  566.  
  567.           case PIE_:          /* PI entity reference (invalid). */
  568.                entpisw = 0;   /* Reset PI entity indicator. */
  569.                synerr(59, pcb);
  570.                continue;
  571.  
  572.           default:
  573.                break;
  574.           }
  575.           break;
  576.      }
  577.      grp[grpcnt++] = 0;       /* NULL pointer indicates end of group. */
  578.      if (es!=essv) synerr(37, pcb);
  579.      return grpcnt;           /* Return number of ptrs in group. */
  580. }
  581. /******************************************************************************/
  582. /* PARSNGRP: Parse notation names, get their dcncbs, and form an array of
  583.              pointers to them.  The array is terminated by a NULL pointer.
  584.              The number of pointers (including the NULL) is returned.
  585.              The grp buffer must have room for GRPCNT+1 members.
  586. */
  587. /*lint +fvr                      Returned value may be ignored. */
  588. UNS parsngrp(grp, pcb)
  589. /*lint -fvr                      Restore normal LINT processing. */
  590. struct dcncb *grp[];          /* Buffer for building the group. */
  591. struct parse  *pcb;           /* Current parse control block. */
  592. {
  593.      UNCH mn[NAMELEN+2];      /* Buffer for parsing a member name. */
  594.      int grpcnt = 0;          /* Number of members in the group. */
  595.      int essv = es;           /* Entity stack level when grp started. */
  596.  
  597.      while (parse(pcb)!=GRPE && grpcnt<GRPCNT) {
  598.           switch (pcb->action) {
  599.           case NAS_:          /* Member name: get its control block. */
  600.                grp[grpcnt++] = dcndef(parsenm(mn, NAMECASE));
  601.                continue;
  602.  
  603.           case EE_:           /* Entity ended (correctly or incorrectly). */
  604.                if (es<essv) {synerr(37, pcb); essv = es;}
  605.                continue;
  606.  
  607.           case PIE_:          /* PI entity reference (invalid). */
  608.                entpisw = 0;   /* Reset PI entity indicator. */
  609.                synerr(59, pcb);
  610.                continue;
  611.  
  612.           default:
  613.                break;
  614.           }
  615.           break;
  616.      }
  617.      grp[grpcnt++] = 0;       /* NULL pointer indicates end of group. */
  618.      if (es!=essv) synerr(37, pcb);
  619.      return grpcnt;           /* Return number of ptrs in group. */
  620. }
  621. /******************************************************************************/
  622. /* COPYGRP: Allocate storage for a group and copy the group into it.
  623. */
  624. PETD *copygrp(pg, grpsz)
  625. PETD pg[];                    /* Pointer to a group (array of etd ptrs). */
  626. UNS grpsz;                    /* Number of ptrs in grp, including final NULL. */
  627. {
  628.      UNS glen;                /* Group length in characters. */
  629.      PETD *gnm;               /* Ptr to permanent name group. */
  630.  
  631.      if (pg==0) return (PETD *)0;
  632.      glen = grpsz * sizeof(struct etd *);
  633.      memcpy( (UNIV)(gnm = (struct etd **)rmalloc(glen)) , (UNIV)pg, glen );
  634.      return gnm;
  635. }
  636. /******************************************************************************/
  637. /* INGRP: Locate an etd in a name group and return its index+1 (or zero
  638.           if not found).
  639. */
  640. int ingrp(pg, ketd)
  641. PETD pg[];                    /* Array of pointers to etds. */
  642. PETD ketd;                    /* Pointer to etd to be found in group. */
  643. {
  644.      int i = 0;               /* Array index. */
  645.  
  646.      while (pg[i]) if (pg[i++]==ketd) return i;
  647.      return 0;
  648. }
  649. /******************************************************************************/
  650. /* PARSELIT: Parse a delimited string and collect it into a token.
  651.              Caller supplies buffer, which must be 1 longer than
  652.              maximum string allowed.
  653.              Caller also supplies character that delimits the string.
  654.              TODO: Return 1 if CDATA, SDATA or NONSGML occurred.
  655. */
  656. VOID parselit(tbuf, pcb, maxlen, del)
  657. UNCH *tbuf;                   /* Work area for tokenization (parmlen+1). */
  658. struct parse *pcb;            /* Current parse control block. */
  659. UNS maxlen;                   /* Maximum length of token. */
  660. UNCH del;                     /* Literal delimiter: LIT LITA PIC EOS */
  661. {
  662.      UNCH *pt = tbuf;         /* Current pointer into tbuf. */
  663.      UNCH lexsv = lexlms[del];/* Saved lexlms value of delimiter. */
  664.      int essv = es;           /* Entity stack level when literal started. */
  665.      UNCH datadel;            /* Delimiter for CDATA/SDATA entity. */
  666.      int parmlen = (int)maxlen;  /* Working limit (to be decremented). */
  667.  
  668.      lexlms[del] = lex.l.litc;   /* Set delimiter to act as literal close. */
  669.      do {
  670.           switch (parse(pcb)) {
  671.                case LP2_:          /* Move 2nd char back to buffer; redo prev.*/
  672.                     REPEATCC;
  673.                case LPR_:          /* Move previous char to buffer; REPEATCC; */
  674.                     REPEATCC;
  675.                case MLA_:          /* Move character to buffer. */
  676.                     *++pt = *FPOS; --parmlen;
  677.                     continue;
  678.  
  679.                case FUN_:          /* Function char found; replace with space.*/
  680.                     *++pt = ' '; --parmlen;
  681.                     continue;
  682.  
  683.                case RSM_:          /* Record start: ccnt=0; ++rcnt.*/
  684.                     ++RCNT; CTRSET(RSCC); *++pt = *FPOS; --parmlen;
  685.                     continue;
  686.  
  687.                case ERX_:          /* Entity reference: cancel LITC delim. */
  688.                case PEX_:          /* Parameter entity ref: cancel LITC delim.*/
  689.                     lexlms[del] = lexsv;
  690.                     continue;
  691.  
  692.                case EE_:
  693.                     if (es<essv) {
  694.                          synerr(37, pcb);
  695.                          essv = es;
  696.                     }
  697.                     /* If back at top level, re-enable the LITC delimiter. */
  698.                     if (es==essv) lexlms[del] = lex.l.litc;
  699.                     continue;
  700.  
  701.                case PIE_:          /* PI entity: not allowed in literal. */
  702.                     entpisw = 0;   /* Reset PI entity indicator. */
  703.                     synerr(59, pcb);
  704.                     continue;
  705.  
  706.                case MLE_:          /* Char not allowed in minimum literal. */
  707.                     synerr(63, pcb);
  708.                     continue;
  709.  
  710.                case DEF_:          /* Data entity: add it to buffer. */
  711.                     if ((parmlen -= (int)datalen+2)<0) {entdatsw = 0; break;}
  712.                     *++pt = datadel =
  713.                          BITON(entdatsw, CDECONT) ? sw.delcdata : sw.delsdata;
  714.                     entdatsw = 0;
  715.                     memcpy( pt+1 , data, datalen );
  716.                     pt += datalen;
  717.                     *++pt = datadel;
  718.                     continue;
  719.  
  720.                case NON_:          /* Non-SGML char (delimited and shifted). */
  721.                     if ((parmlen -= 2)<0) break;
  722.                     memcpy( pt+1 , nonchbuf, 2 );
  723.                     pt += 2;
  724.                     continue;
  725.  
  726.                case RPR_:          /* Remove character from buffer. */
  727.                     --pt; ++parmlen;
  728.                     break;
  729.  
  730.                case EOD_:
  731.                     exiterr(92, pcb);
  732.               exiterr(133, pcb);
  733.               sgmlerr(133, pcb, NULL, NULL);
  734.  
  735.                default:
  736.                     break;
  737.           }
  738.           break;
  739.      } while (parmlen>=0 && pcb->action!=TER_);
  740.  
  741.      if (parmlen<0) {--pt; sgmlerr(134, pcb, ntoa((int)maxlen),NULL); REPEATCC;}
  742.      datalen = (UNS)(pt-tbuf);/* To return PI string to text processor. */
  743.      *++pt = EOS;
  744.      *tbuf = (char)(++pt - tbuf);
  745.      lexlms[del] = lexsv;     /* Restore normal delimiter handling. */
  746.      if (es!=essv) synerr(37, pcb);
  747.      return;
  748. }
  749. /******************************************************************************/
  750. /* PARSEMD: Parser for markup declarations.
  751.             It returns a token each time it is called.
  752.  
  753. */
  754. /*lint +fvr                      Returned value may be ignored. */
  755. int parsemd(pt, namecase, lpcb, tokenlen)
  756. /*lint -fvr                      Restore normal LINT processing. */
  757. UNCH *pt;                     /* Token buffer: >=tokenlen+2. */
  758. int namecase;                 /* Case translation: ENTCASE NAMECASE AVALCASE. */
  759. struct parse *lpcb;           /* Parse control block for literal parse. */
  760. UNS tokenlen;                 /* Max length of expected token: NAMELEN LITLEN */
  761. {
  762.      struct parse *pcb;       /* Current parse control block. */
  763.  
  764.      pcb = (lpcb) ? &pcbmd : &pcbmdc;  /* If no literal pcb, dcl is comment. */
  765.  
  766.      doparse: while (parse(pcb)==EE_)
  767.           if (es<mdessv) {synerr(37, pcb); mdessv = es;}
  768.      if (pcb->action==PIE_) { /* PI entity reference not allowed. */
  769.           entpisw = 0;        /* Reset PI entity indicator. */
  770.           synerr(59, pcb);
  771.           goto doparse;
  772.      }
  773.      ++parmno;           /* Increment parameter counter. */
  774.      switch (pcb->action) {
  775.      case CDR:           /* COM[1] (MINUS) occurred previously. */
  776.           REPEATCC;
  777.           return (int)pcb->action;
  778.      case LIT:           /* Literal: CDATA with LIT delimiter. */
  779.           parselit(pt, lpcb, tokenlen, lex.d.lit);
  780.           return (int)pcb->action;
  781.      case LITE:          /* Literal: CDATA with LITA delimiter. */
  782.           parselit(pt, lpcb, tokenlen, lex.d.lita);
  783.           return((int)(pcb->action = LIT));
  784.      case RNS:           /* Reserved name started (after RNI). */
  785.           parsenm(pt, NAMECASE);
  786.           return (int)pcb->action;
  787.      case NAS:           /* Name started. */
  788.           if (namecase!=AVALCASE) {
  789.                parsenm(pt, namecase);
  790.                return (int)pcb->action;
  791.           }
  792.           /* Treat attribute value as name character string. */
  793.      case NMT:           /* Name token string. */
  794.           parsetkn(pt, NMC, (int)tokenlen);  /* Get undelimited value. */
  795.           return (int)pcb->action;
  796.      case NUM:           /* Number or number token string. */
  797.           parsetkn(pt, (char)((int)tokenlen<=NAMELEN ? NUM:NMC), (int)tokenlen);
  798.           return (int)pcb->action;
  799.      case EOD_:
  800.           exiterr(133, pcb);
  801.           /* EXIT */
  802.      default:            /* End of declaration. */
  803.           return (int)pcb->action; /* EMD GRPS MGRP PEN PGRP */
  804.      }
  805.      /*lint -unreachable*/
  806. }
  807. /******************************************************************************/
  808. #define MCON gbuf->ttype      /* Model type (content attributes). */
  809. /******************************************************************************/
  810. /* PARSEMOD: If the declared content was a keyword, the token count is zero
  811.              and it is only necessary to save the type.  Otherwise,
  812.              collect the outermost token count and model type bytes for a model.
  813.              The count includes tokens found in nested groups also.
  814.              After building the model, parse for its occurrence indicator.
  815. */
  816. struct thdr *parsemod(dctype)
  817. int dctype;                        /* Content type (0=model). */
  818. {
  819.      gbuf[0].ttype = (char)dctype; /* Initialize content flags byte. */
  820.      if (dctype) {gbuf[0].tu.tnum = 0; return gbuf;} /* Return if not model. */
  821.  
  822.      gbuf[0].tu.tnum = 1;          /* Count 1st group, but not model header. */
  823.      gbuf[1].ttype = 0;            /* Initialize 1st group type ... */
  824.      gbuf[1].tu.tnum = 0;          /* and count. */
  825.      grplvl = 1;                   /* Content model is 1st level group. */
  826.      pcbgrcm.newstate = 0;        /* Go parse the model group. */
  827.      /* Empty group is trapped during syntax parse; other errors return NULL. */
  828.      if (!parsegcm(&pcbgrcm, &gbuf[1], &gbuf[0])) return (struct thdr *)0;
  829.      parse(&pcbgrcs);             /* Get the model suffix, if there is one. */
  830.      switch(pcbgrcs.action) {
  831.      case OPT:                     /* OPT occurrence indicator for model. */
  832.           SET(gbuf[1].ttype, TOPT);
  833.           break;
  834.      case REP:                     /* REP occurrence indicator for model. */
  835.           SET(gbuf[1].ttype, TREP);
  836.           break;
  837.      case OREP:                    /* OREP occurrence indicator for model. */
  838.           SET(gbuf[1].ttype, TOREP);
  839.           break;
  840.      default:                      /* RCR_: Repeat char and return. */
  841.           break;
  842.      }
  843.      return gbuf;
  844. }
  845. /******************************************************************************/
  846. /* PARSEGCM: Collect token headers (struct thdr) into a group (array).
  847.              An etd is defined for each GI (if none exists) and its pointer is
  848.              stored in the header.  The function is called recursively.
  849. */
  850. struct thdr *parsegcm(pcb, pgh, gbuf)
  851. struct parse *pcb;                 /* Current parse control block. */
  852. struct thdr *pgh;                  /* Current group header in group buffer. */
  853. struct thdr *gbuf;                 /* Header for outermost group (model). */
  854. {
  855.      UNCH nm[NAMELEN+2];           /* Buffer for name tokens. */
  856.      struct thdr *pg=pgh;          /* Current group token. */
  857.      struct thdr *pgsv=pgh;        /* Saved current token for occ indicator. */
  858.      int optcnt = 0;               /* Count of optional tokens in group. */
  859.      int essv = es;                /* Entity stack level when grp started. */
  860.  
  861.     while (gbuf->tu.tnum<=GRPGTCNT && pgh->tu.tnum<=GRPCNT && parse(pcb)!=GRPE)
  862.      switch (pcb->action) {
  863.  
  864.      case NAS_:          /* GI name: get its etd and store it. */
  865.           ++gbuf->tu.tnum; ++pgh->tu.tnum;
  866.           (pgsv = ++pg)->ttype = TTETD;
  867.           pg->tu.thetd = etddef(parsenm(nm, NAMECASE));
  868.           SET(MCON, MGI);
  869.           continue;
  870.  
  871.      case RNS_:          /* Reserved name started (#PCDATA). */
  872.           parsenm(nm, NAMECASE);
  873.           if (strcmp(nm+1, syn.k.pcdata)) {
  874.                mderr(116, ntoa(gbuf->tu.tnum), nm+1);
  875.                return (struct thdr *)0;
  876.           }
  877.           /* If #PCDATA is the first non-group token, model is a phrase. */
  878.           if (!MCON) SET(MCON, MPHRASE);
  879.      case DTAG:          /* Data tag template ignored; treat as #PCDATA. */
  880.           if (pcb->action==DTAG) SET(pgh->ttype, TTSEQ); /* DTAG is SEQ grp. */
  881.           ++gbuf->tu.tnum; ++pgh->tu.tnum;
  882.           (++pg)->ttype = TTCHARS+TOREP;/* #PCDATA is OPT and REP. */
  883.           pg->tu.thetd = ETDCDATA;
  884.           ++optcnt;                     /* Ct opt tokens to see if grp is opt.*/
  885.           SET(MCON, MCHARS);
  886.           continue;
  887.  
  888.      case GRP_:          /* Group started. */
  889.           ++gbuf->tu.tnum; ++pgh->tu.tnum;
  890.           (pgsv = ++pg)->ttype = 0;     /* Type will be set by connector. */
  891.           pg->tu.tnum = 0;              /* Group has number instead of etd. */
  892.           if (++grplvl>GRPLVL) {
  893.                mderr(115, ntoa(gbuf->tu.tnum), NULL);
  894.                return (struct thdr *)0;
  895.           }
  896.           pg = parsegcm(pcb, pg, gbuf);
  897.           if (!pg) return (struct thdr *)0;
  898.           if (GET(pgsv->ttype, TOPT)) ++optcnt;  /* Indicate nested opt grp. */
  899.           --grplvl;
  900.           continue;
  901.  
  902.      case OREP:          /* OREP occurrence indicator for current token.*/
  903.           SET(pgsv->ttype, TREP);
  904.                          /* Now treat like OPT. */
  905.      case OPT:           /* OPT occurrence indicator for current token. */
  906.           if (GET(pgsv->ttype, TOPT)) continue;  /* Exit if nested opt grp. */
  907.           SET(pgsv->ttype, TOPT);
  908.           ++optcnt;      /* Count opt tokens to see if grp is optional. */
  909.           continue;
  910.      case REP:           /* REP occurrence indicator for current token. */
  911.           SET(pgsv->ttype, TREP);
  912.           continue;
  913.  
  914.      case OR:            /* OR connector found. */
  915.           if BITOFF(pgh->ttype, TTAND) SET(pgh->ttype, TTOR);
  916.           else if (GET(pgh->ttype, TTAND)!=TTOR)
  917.                mderr(55, ntoa(gbuf->tu.tnum), NULL);
  918.           continue;
  919.      case AND:           /* AND connector found. */
  920.           if BITOFF(pgh->ttype, TTAND) SET(pgh->ttype, TTAND);
  921.           else if (GET(pgh->ttype, TTAND)!=TTAND)
  922.                mderr(55, ntoa(gbuf->tu.tnum), NULL);
  923.           continue;
  924.      case SEQ:           /* SEQ connector found. */
  925.           if BITOFF(pgh->ttype, TTAND) SET(pgh->ttype, TTSEQ);
  926.           else if (GET(pgh->ttype, TTAND)!=TTSEQ)
  927.                mderr(55, ntoa(gbuf->tu.tnum), NULL);
  928.           continue;
  929.  
  930.      case EE_:           /* Entity ended (correctly or incorrectly). */
  931.           if (es<essv) {synerr(37, pcb); essv = es;}
  932.           continue;
  933.  
  934.      case PIE_:          /* PI entity reference (not permitted). */
  935.           entpisw = 0;   /* Reset PI entity indicator. */
  936.           synerr(59, pcb);
  937.           continue;
  938.  
  939.      default:            /* Syntax errors return in disgrace. */
  940.           synerr(37, pcb);
  941.           return (struct thdr *)0;
  942.      }
  943.      if (pgh->tu.tnum>GRPCNT) {
  944.           mderr(113, ntoa(gbuf->tu.tnum), NULL);
  945.           return (struct thdr *)0;
  946.      }
  947.      if (gbuf->tu.tnum>GRPGTCNT) {
  948.           mderr(113, ntoa(gbuf->tu.tnum), NULL);
  949.           return (struct thdr *)0;
  950.      }
  951.      if (pgh->tu.tnum==1) SET(pgh->ttype, TTSEQ); /* Unit grp is SEQ. */
  952.      /* An optional token in an OR group makes the group optional. */
  953.      if (GET(pgh->ttype, TTMASK)==TTOR && optcnt) SET(pgh->ttype, TOPT);
  954.      /* If all tokens in any group are optional, so is the group. */
  955.      if (pgh->tu.tnum<=optcnt) SET(pgh->ttype, TOPT);
  956.  
  957.      if (es!=essv) synerr(37, pcb);
  958.      return pg;                             /* Return pointer to GRPS token. */
  959. }
  960. /******************************************************************************/
  961. /* PARSENM: Parser for SGML names, which can be translated with LEXTRAN.
  962.             The input is read from the entity stack.  CC is 1st char of name.
  963.             Returns a pointer to the parsed name.
  964. */
  965. /*lint +fvr                      Returned value may be ignored. */
  966. UNCH *parsenm(tbuf, nc)
  967. /*lint -fvr                      Restore normal LINT processing. */
  968. UNCH *tbuf;                   /* Buffer for name: >=NAMELEN+2. */
  969. int nc;                       /* Namecase translation: 1=yes; 0=no. */
  970. {
  971.      UNCH   len;              /* Length of name (incl EOS & length byte). */
  972.  
  973.      *(tbuf + (len = 1) ) = nc ? lextran[*FPOS] : *FPOS;
  974.      while ((NEWCC, lextoke[*FPOS]>=NMC) && (len<NAMELEN)) {
  975. #ifndef FINAL
  976.           if (trace) tracetkn(NMC, lextoke);
  977. #endif
  978.           if (lextoke[*(tbuf + ++len) = (nc ? lextran[*FPOS] : *FPOS)]==EOB) {
  979.                --len;
  980.                entget();
  981.           }
  982.      }
  983.      REPEATCC;                       /* Put back the non-token character. */
  984.      *(tbuf + ++len) = EOS;          /* Terminate name with standard EOS. */
  985.      *tbuf = ++len;                  /* Store length ahead of name. */
  986.      return tbuf;
  987. }
  988. /******************************************************************************/
  989. /* PARSETKN: Parser for start-tag attribute value tokens.
  990.              First character of token is already in *FPOS.
  991.              Returns a pointer to the parsed token.
  992. */
  993. /*lint +fvr                      Returned value may be ignored. */
  994. UNCH *parsetkn(tbuf, scope, maxlen)
  995. /*lint -fvr                      Restore normal LINT processing. */
  996. UNCH   *tbuf;                 /* Buffer for token: >=maxlen+2. */
  997. UNCH   scope;                 /* Minimum lexical class allowed. */
  998. int    maxlen;                /* Maximum length of a token. */
  999. {
  1000.      UNCH   len;              /* Length of token (incl EOS & length byte). */
  1001.  
  1002.      *(tbuf + (len=1)) = *FPOS;  /* 1st token char was found by caller. */
  1003.      while ((NEWCC, lextoke[*FPOS]>=scope) && (len<(char)maxlen)) {
  1004. #ifndef FINAL
  1005.           if (trace) tracetkn((int)scope, lextoke);
  1006. #endif
  1007.           if (lextoke[*(tbuf + ++len) = *FPOS]==EOB) {
  1008.                --len;
  1009.                entget();
  1010.           }
  1011.      }
  1012.      REPEATCC;                /* Put back the non-token character. */
  1013.      *(tbuf + ++len) = EOS;   /* Terminate token with standard EOS. */
  1014.      *tbuf = ++len;           /* Store length ahead of token. */
  1015.      return tbuf;
  1016. }
  1017. /******************************************************************************/
  1018. /* PARSESEQ: Parser for blank sequences (i.e., space and TAB characters ).
  1019.              First character of sequence is already in *FPOS.
  1020. */
  1021. VOID parseseq(tbuf, maxlen)
  1022. UNCH   tbuf[];                /* Buffer for storing found sequence. */
  1023. int    maxlen;                /* Maximum length of a blank sequence. */
  1024. {
  1025.      UNCH   *ps;              /* Current position in tbuf. */
  1026.  
  1027.      *(ps = tbuf) = *FPOS; datalen = 1;    /* 1st char was found by caller. */
  1028.           loop: while ( (NEWCC, lextoke[*FPOS]==SEP) && ++datalen<=maxlen ) {
  1029. #ifndef FINAL
  1030.                if (trace) tracetkn((int)datalen, lextoke);
  1031. #endif
  1032.                *(++ps) = *FPOS;
  1033.           }
  1034.           if (*FPOS==EOB) {entget(); goto loop;}     /* Still in sequence. */
  1035.      return;                  /* Character after sequence is in *FPOS. */
  1036. }
  1037. /******************************************************************************/
  1038. /* S2VALNM: Parser for attribute values that are tokenized like names.
  1039.             The input is read from a string (hence S ("string") 2 ("to") VALNM).
  1040.             It stops at the first bad character.
  1041.             Returns a pointer to the created name.
  1042. */
  1043. UNCH *s2valnm(n, s, scope, nc)
  1044. UNCH *n;                      /* Name to be created. */
  1045. UNCH *s;                      /* Source string to be parsed as name. */
  1046. UNCH scope;                   /* Minimum lexical class allowed. */
  1047. int nc;                       /* Namecase translation: 1=yes; 0=no. */
  1048. {
  1049.      UNCH len = 0;            /* Length of name (incl EOS and length). */
  1050.  
  1051.      while (lextoke[*s]>=scope && len<NAMELEN)
  1052.           *(n + ++len) = (nc ? lextran[*s++] : *s++)
  1053.      ;
  1054.      *(n + ++len) = EOS;      /* Terminate name with standard EOS. */
  1055.      *n = ++len;              /* Store length ahead of name. */
  1056.      return n;
  1057. }
  1058. /******************************************************************************/
  1059. /* PARSEVAL: Parser for attribute values.
  1060.              The input is read from a string and tokenized in a buffer.
  1061.              The input is terminated by EOS.
  1062.              Each token is preceded by its actual length; there is no EOS.
  1063.              If an error occurs while parsing, or
  1064.              if a token doesn't conform, set the token count to 0 to show that
  1065.              value was not tokenized and return the error code.
  1066.              After successful parse, return buffer length and 0 error code.
  1067.              The number of tokens found is set in external variable tokencnt.
  1068. */
  1069. int parseval(s, atype, tbuf)
  1070. UNCH *s;                      /* Source string to be parsed as token list. */
  1071. UNS atype;                    /* Type of token list expected. */
  1072. UNCH *tbuf;                   /* Work area for tokenization. */
  1073. {
  1074.      UNCH *slim = s+*s-2;     /* Ptr to last char of s: to avoid overruns. */
  1075.      UNCH *pt = tbuf+1;       /* Current pointer into tbuf; lv room for len. */
  1076.  
  1077.      pcbval.newstate = 0; tokencnt = 0;
  1078. /*lint -e716*/
  1079.      while (1) {
  1080. /*lint +e716*/
  1081.           do {
  1082.                pcbval.input = lextoke[*++s];
  1083.                pcbval.state = pcbval.newstate;
  1084.                pcbval.newstate = (*(pcbval.ptab + pcbval.state)) [pcbval.input];
  1085.                pcbval.action = (*(pcbval.ptab + pcbval.state+1)) [pcbval.input];
  1086. #ifndef FINAL
  1087.                if (atrace) traceval(&pcbval, atype, s, tokencnt);
  1088. #endif
  1089.           } while (pcbval.action==_NOP);
  1090.  
  1091.           switch (pcbval.action) {
  1092.           case _INV:          /* Invalid character; terminate parse. */
  1093.                if (s>slim) goto alldone;  /* Normal termination. */
  1094.                tokencnt = 0;  /* Value was not tokenized. */
  1095.                return(14);
  1096.           case _LEN:          /* Length limit of token exceeded; end parse. */
  1097.                tokencnt = 0;  /* Value was not tokenized. */
  1098.                return(15);
  1099.           default:            /* Token begun: _NUM, _NAS, or _NMT. */
  1100.                break;
  1101.           }
  1102.  
  1103.           ++tokencnt;         /* One token per iteration. */
  1104.           switch (atype) {
  1105.           case AENTITY:
  1106.                if (tokencnt>1) {tokencnt = 0; return(16);}
  1107.           case AENTITYS:
  1108.                if (pcbval.action!=_NAS) {tokencnt = 0; return(17);}
  1109.                s2valnm(pt, s, NMC, ENTCASE);
  1110.                break;
  1111.  
  1112.           case AID:
  1113.           case AIDREF:
  1114.           case ANAME:
  1115.           case ANOTEGRP:
  1116.                if (tokencnt>1) {tokencnt = 0; return(16);}
  1117.           case AIDREFS:
  1118.           case ANAMES:
  1119.                if (pcbval.action!=_NAS) {tokencnt = 0; return(17);}
  1120.                s2valnm(pt, s, NMC, NAMECASE);
  1121.                break;
  1122.  
  1123.           case ANMTGRP:
  1124.           case ANMTOKE:
  1125.                if (tokencnt>1) {tokencnt = 0; return(16);}
  1126.           case ANMTOKES:
  1127.                /* No test needed because _NMT, _NUM and _NAS are all valid. */
  1128.                s2valnm(pt, s, NMC, NAMECASE);
  1129.                break;
  1130.  
  1131.           case ANUMBER:
  1132.                if (tokencnt>1) {tokencnt = 0; return(16);}
  1133.           case ANUMBERS:
  1134.                if (pcbval.action!=_NUM) {tokencnt = 0; return(17);}
  1135.                s2valnm(pt, s, NU, NAMECASE);
  1136.                break;
  1137.  
  1138.           case ANUTOKE:
  1139.                if (tokencnt>1) {tokencnt = 0; return(16);}
  1140.           case ANUTOKES:
  1141.                if (pcbval.action!=_NUM) {tokencnt = 0; return(17);}
  1142.                s2valnm(pt, s, NMC, NAMECASE);
  1143.                break;
  1144.           }
  1145.           s  += (*pt -= 2)-1;      /* Point to end of token in source. */
  1146.           pt += *pt+1;             /* Point to buffer for next token. */
  1147.      }
  1148.      alldone:
  1149.      *pt++ = EOS;                  /* EOS allows clean traces. */
  1150.      /*lint -e514*/                /* Allow unusual Booleans. */
  1151.      pvalptr = tbuf+(atype<ATKNLIST);  /* Pt to 1st token if only one. */
  1152.      /*lint +e514*/                /* Don't allow unusual Booleans. */
  1153.      *pvalptr = (char)(pt-pvalptr);/* Save length of token list, incl. length.*/
  1154.      return(*pvalptr<=2 ? 25 : 0); /* Null value is an error. */
  1155. }
  1156. /******************************************************************************/
  1157. #undef DEFVAL
  1158. #undef DEFNUM
  1159. #undef DEFLEN
  1160. #undef MCON
  1161. /******************************************************************************/
  1162.